home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / controls / SWFLoader.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  30.5 KB  |  968 lines
  1. package mx.controls
  2. {
  3.    import flash.display.Bitmap;
  4.    import flash.display.DisplayObject;
  5.    import flash.display.DisplayObjectContainer;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.events.Event;
  9.    import flash.events.HTTPStatusEvent;
  10.    import flash.events.IOErrorEvent;
  11.    import flash.events.ProgressEvent;
  12.    import flash.events.SecurityErrorEvent;
  13.    import flash.geom.Rectangle;
  14.    import flash.net.URLRequest;
  15.    import flash.system.ApplicationDomain;
  16.    import flash.system.Capabilities;
  17.    import flash.system.LoaderContext;
  18.    import flash.system.SecurityDomain;
  19.    import flash.utils.ByteArray;
  20.    import mx.core.Application;
  21.    import mx.core.FlexLoader;
  22.    import mx.core.FlexVersion;
  23.    import mx.core.IFlexDisplayObject;
  24.    import mx.core.IUIComponent;
  25.    import mx.core.UIComponent;
  26.    import mx.core.mx_internal;
  27.    import mx.events.FlexEvent;
  28.    import mx.managers.CursorManager;
  29.    import mx.managers.ISystemManager;
  30.    import mx.managers.SystemManagerGlobals;
  31.    import mx.styles.ISimpleStyleClient;
  32.    import mx.utils.LoaderUtil;
  33.    
  34.    use namespace mx_internal;
  35.    
  36.    public class SWFLoader extends UIComponent
  37.    {
  38.       mx_internal static const VERSION:String = "3.0.0.0";
  39.       
  40.       mx_internal var contentHolder:DisplayObject;
  41.       
  42.       private var brokenImage:Boolean = false;
  43.       
  44.       private var _bytesLoaded:Number = NaN;
  45.       
  46.       private var _autoLoad:Boolean = true;
  47.       
  48.       private var _loaderContext:LoaderContext;
  49.       
  50.       private var requestedURL:URLRequest;
  51.       
  52.       private var _showBusyCursor:Boolean = false;
  53.       
  54.       private var _scaleContent:Boolean = true;
  55.       
  56.       private var _bytesTotal:Number = NaN;
  57.       
  58.       private var flexContent:Boolean = false;
  59.       
  60.       private var explicitLoaderContext:Boolean = false;
  61.       
  62.       private var _maintainAspectRatio:Boolean = true;
  63.       
  64.       private var resizableContent:Boolean = false;
  65.       
  66.       private var brokenImageBorder:IFlexDisplayObject;
  67.       
  68.       private var isContentLoaded:Boolean = false;
  69.       
  70.       private var attemptingChildAppDomain:Boolean = false;
  71.       
  72.       private var _trustContent:Boolean = false;
  73.       
  74.       private var scaleContentChanged:Boolean = false;
  75.       
  76.       private var _source:Object;
  77.       
  78.       private var contentRequestID:String = null;
  79.       
  80.       private var contentChanged:Boolean = false;
  81.       
  82.       public function SWFLoader()
  83.       {
  84.          super();
  85.          tabChildren = true;
  86.          tabEnabled = false;
  87.          addEventListener(FlexEvent.INITIALIZE,initializeHandler);
  88.          showInAutomationHierarchy = false;
  89.       }
  90.       
  91.       [Bindable("trustContentChanged")]
  92.       public function get trustContent() : Boolean
  93.       {
  94.          return _trustContent;
  95.       }
  96.       
  97.       public function set trustContent(param1:Boolean) : void
  98.       {
  99.          if(_trustContent != param1)
  100.          {
  101.             _trustContent = param1;
  102.             invalidateProperties();
  103.             invalidateSize();
  104.             invalidateDisplayList();
  105.             dispatchEvent(new Event("trustContentChanged"));
  106.          }
  107.       }
  108.       
  109.       public function get contentHeight() : Number
  110.       {
  111.          return !!mx_internal::contentHolder ? mx_internal::contentHolder.height : NaN;
  112.       }
  113.       
  114.       [Bindable("maintainAspectRatioChanged")]
  115.       public function get maintainAspectRatio() : Boolean
  116.       {
  117.          return _maintainAspectRatio;
  118.       }
  119.       
  120.       private function contentLoaderInfo_progressEventHandler(param1:ProgressEvent) : void
  121.       {
  122.          _bytesTotal = param1.bytesTotal;
  123.          _bytesLoaded = param1.bytesLoaded;
  124.          dispatchEvent(param1);
  125.       }
  126.       
  127.       private function contentLoaded() : void
  128.       {
  129.          var loaderInfo:LoaderInfo = null;
  130.          isContentLoaded = true;
  131.          if(mx_internal::contentHolder is Loader)
  132.          {
  133.             loaderInfo = Loader(mx_internal::contentHolder).contentLoaderInfo;
  134.          }
  135.          resizableContent = false;
  136.          if(loaderInfo)
  137.          {
  138.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  139.             {
  140.                resizableContent = true;
  141.             }
  142.             if(resizableContent)
  143.             {
  144.                try
  145.                {
  146.                   flexContent = Loader(mx_internal::contentHolder).content is IFlexDisplayObject;
  147.                }
  148.                catch(e:Error)
  149.                {
  150.                   flexContent = false;
  151.                }
  152.             }
  153.          }
  154.          try
  155.          {
  156.             if(tabChildren && mx_internal::contentHolder is Loader && Loader(mx_internal::contentHolder).content is DisplayObjectContainer)
  157.             {
  158.                Loader(mx_internal::contentHolder).tabChildren = true;
  159.                DisplayObjectContainer(Loader(mx_internal::contentHolder).content).tabChildren = true;
  160.             }
  161.          }
  162.          catch(e:Error)
  163.          {
  164.          }
  165.          invalidateSize();
  166.          invalidateDisplayList();
  167.       }
  168.       
  169.       override public function get baselinePosition() : Number
  170.       {
  171.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  172.          {
  173.             return 0;
  174.          }
  175.          return super.baselinePosition;
  176.       }
  177.       
  178.       private function unScaleContent() : void
  179.       {
  180.          mx_internal::contentHolder.scaleX = 1;
  181.          mx_internal::contentHolder.scaleY = 1;
  182.          mx_internal::contentHolder.x = 0;
  183.          mx_internal::contentHolder.y = 0;
  184.       }
  185.       
  186.       private function get contentHolderHeight() : Number
  187.       {
  188.          var loaderInfo:LoaderInfo = null;
  189.          var content:IFlexDisplayObject = null;
  190.          var testContent:DisplayObject = null;
  191.          if(mx_internal::contentHolder is Loader)
  192.          {
  193.             loaderInfo = Loader(mx_internal::contentHolder).contentLoaderInfo;
  194.          }
  195.          if(loaderInfo)
  196.          {
  197.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  198.             {
  199.                try
  200.                {
  201.                   content = Loader(mx_internal::contentHolder).content as IFlexDisplayObject;
  202.                   if(content)
  203.                   {
  204.                      return content.measuredHeight;
  205.                   }
  206.                }
  207.                catch(error:Error)
  208.                {
  209.                   return mx_internal::contentHolder.height;
  210.                }
  211.             }
  212.             else
  213.             {
  214.                try
  215.                {
  216.                   testContent = Loader(mx_internal::contentHolder).content;
  217.                }
  218.                catch(error:Error)
  219.                {
  220.                   return mx_internal::contentHolder.height;
  221.                }
  222.             }
  223.             return loaderInfo.height;
  224.          }
  225.          if(mx_internal::contentHolder is IUIComponent)
  226.          {
  227.             return IUIComponent(mx_internal::contentHolder).getExplicitOrMeasuredHeight();
  228.          }
  229.          if(mx_internal::contentHolder is IFlexDisplayObject)
  230.          {
  231.             return IFlexDisplayObject(mx_internal::contentHolder).measuredHeight;
  232.          }
  233.          return mx_internal::contentHolder.height;
  234.       }
  235.       
  236.       public function set maintainAspectRatio(param1:Boolean) : void
  237.       {
  238.          _maintainAspectRatio = param1;
  239.          dispatchEvent(new Event("maintainAspectRatioChanged"));
  240.       }
  241.       
  242.       public function set showBusyCursor(param1:Boolean) : void
  243.       {
  244.          if(_showBusyCursor != param1)
  245.          {
  246.             _showBusyCursor = param1;
  247.             if(_showBusyCursor)
  248.             {
  249.                CursorManager.mx_internal::registerToUseBusyCursor(this);
  250.             }
  251.             else
  252.             {
  253.                CursorManager.mx_internal::unRegisterToUseBusyCursor(this);
  254.             }
  255.          }
  256.       }
  257.       
  258.       [Bindable("complete")]
  259.       public function get bytesTotal() : Number
  260.       {
  261.          return _bytesTotal;
  262.       }
  263.       
  264.       private function initializeHandler(param1:FlexEvent) : void
  265.       {
  266.          if(contentChanged)
  267.          {
  268.             contentChanged = false;
  269.             if(_autoLoad)
  270.             {
  271.                load(_source);
  272.             }
  273.          }
  274.       }
  275.       
  276.       public function get showBusyCursor() : Boolean
  277.       {
  278.          return _showBusyCursor;
  279.       }
  280.       
  281.       public function set scaleContent(param1:Boolean) : void
  282.       {
  283.          if(_scaleContent != param1)
  284.          {
  285.             _scaleContent = param1;
  286.             scaleContentChanged = true;
  287.             invalidateDisplayList();
  288.          }
  289.          dispatchEvent(new Event("scaleContentChanged"));
  290.       }
  291.       
  292.       private function contentLoaderInfo_openEventHandler(param1:Event) : void
  293.       {
  294.          dispatchEvent(param1);
  295.       }
  296.       
  297.       override public function regenerateStyleCache(param1:Boolean) : void
  298.       {
  299.          var sm:ISystemManager = null;
  300.          var recursive:Boolean = param1;
  301.          super.regenerateStyleCache(recursive);
  302.          try
  303.          {
  304.             sm = content as ISystemManager;
  305.             if(sm != null)
  306.             {
  307.                Object(sm).regenerateStyleCache(recursive);
  308.             }
  309.          }
  310.          catch(error:Error)
  311.          {
  312.          }
  313.       }
  314.       
  315.       [Bindable("loaderContextChanged")]
  316.       public function get loaderContext() : LoaderContext
  317.       {
  318.          return _loaderContext;
  319.       }
  320.       
  321.       private function getHorizontalAlignValue() : Number
  322.       {
  323.          var _loc1_:String = getStyle("horizontalAlign");
  324.          if(_loc1_ == "left")
  325.          {
  326.             return 0;
  327.          }
  328.          if(_loc1_ == "right")
  329.          {
  330.             return 1;
  331.          }
  332.          return 0.5;
  333.       }
  334.       
  335.       [Bindable("progress")]
  336.       public function get percentLoaded() : Number
  337.       {
  338.          var _loc1_:Number = isNaN(_bytesTotal) || _bytesTotal == 0 ? 0 : 100 * (_bytesLoaded / _bytesTotal);
  339.          if(isNaN(_loc1_))
  340.          {
  341.             _loc1_ = 0;
  342.          }
  343.          return _loc1_;
  344.       }
  345.       
  346.       private function contentLoaderInfo_unloadEventHandler(param1:Event) : void
  347.       {
  348.          dispatchEvent(param1);
  349.       }
  350.       
  351.       mx_internal function contentLoaderInfo_completeEventHandler(param1:Event) : void
  352.       {
  353.          if(LoaderInfo(param1.target).loader != mx_internal::contentHolder)
  354.          {
  355.             return;
  356.          }
  357.          dispatchEvent(param1);
  358.          contentLoaded();
  359.       }
  360.       
  361.       override public function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  362.       {
  363.          var sm:ISystemManager = null;
  364.          var styleProp:String = param1;
  365.          var recursive:Boolean = param2;
  366.          super.notifyStyleChangeInChildren(styleProp,recursive);
  367.          try
  368.          {
  369.             sm = content as ISystemManager;
  370.             if(sm != null)
  371.             {
  372.                Object(sm).notifyStyleChangeInChildren(styleProp,recursive);
  373.             }
  374.          }
  375.          catch(error:Error)
  376.          {
  377.          }
  378.       }
  379.       
  380.       [Bindable("autoLoadChanged")]
  381.       public function get autoLoad() : Boolean
  382.       {
  383.          return _autoLoad;
  384.       }
  385.       
  386.       public function set source(param1:Object) : void
  387.       {
  388.          if(_source != param1)
  389.          {
  390.             _source = param1;
  391.             contentChanged = true;
  392.             invalidateProperties();
  393.             invalidateSize();
  394.             invalidateDisplayList();
  395.             dispatchEvent(new Event("sourceChanged"));
  396.          }
  397.       }
  398.       
  399.       [Bindable("sourceChanged")]
  400.       public function get source() : Object
  401.       {
  402.          return _source;
  403.       }
  404.       
  405.       private function contentLoaderInfo_httpStatusEventHandler(param1:HTTPStatusEvent) : void
  406.       {
  407.          dispatchEvent(param1);
  408.       }
  409.       
  410.       public function set loaderContext(param1:LoaderContext) : void
  411.       {
  412.          _loaderContext = param1;
  413.          explicitLoaderContext = true;
  414.          dispatchEvent(new Event("loaderContextChanged"));
  415.       }
  416.       
  417.       private function get contentHolderWidth() : Number
  418.       {
  419.          var loaderInfo:LoaderInfo = null;
  420.          var content:IFlexDisplayObject = null;
  421.          var testContent:DisplayObject = null;
  422.          if(mx_internal::contentHolder is Loader)
  423.          {
  424.             loaderInfo = Loader(mx_internal::contentHolder).contentLoaderInfo;
  425.          }
  426.          if(loaderInfo)
  427.          {
  428.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  429.             {
  430.                try
  431.                {
  432.                   content = Loader(mx_internal::contentHolder).content as IFlexDisplayObject;
  433.                   if(content)
  434.                   {
  435.                      return content.measuredWidth;
  436.                   }
  437.                }
  438.                catch(error:Error)
  439.                {
  440.                   return mx_internal::contentHolder.width;
  441.                }
  442.             }
  443.             else
  444.             {
  445.                try
  446.                {
  447.                   testContent = Loader(mx_internal::contentHolder).content;
  448.                }
  449.                catch(error:Error)
  450.                {
  451.                   return mx_internal::contentHolder.width;
  452.                }
  453.             }
  454.             return loaderInfo.width;
  455.          }
  456.          if(mx_internal::contentHolder is IUIComponent)
  457.          {
  458.             return IUIComponent(mx_internal::contentHolder).getExplicitOrMeasuredWidth();
  459.          }
  460.          if(mx_internal::contentHolder is IFlexDisplayObject)
  461.          {
  462.             return IFlexDisplayObject(mx_internal::contentHolder).measuredWidth;
  463.          }
  464.          return mx_internal::contentHolder.width;
  465.       }
  466.       
  467.       private function loadContent(param1:Object) : DisplayObject
  468.       {
  469.          var child:DisplayObject = null;
  470.          var cls:Class = null;
  471.          var url:String = null;
  472.          var byteArray:ByteArray = null;
  473.          var loader:Loader = null;
  474.          var lc:LoaderContext = null;
  475.          var rootURL:String = null;
  476.          var lastIndex:int = 0;
  477.          var message:String = null;
  478.          var classOrString:Object = param1;
  479.          if(classOrString is Class)
  480.          {
  481.             cls = Class(classOrString);
  482.          }
  483.          else if(classOrString is String)
  484.          {
  485.             try
  486.             {
  487.                cls = Class(systemManager.getDefinitionByName(String(classOrString)));
  488.             }
  489.             catch(e:Error)
  490.             {
  491.             }
  492.             url = String(classOrString);
  493.          }
  494.          else if(classOrString is ByteArray)
  495.          {
  496.             byteArray = ByteArray(classOrString);
  497.          }
  498.          else
  499.          {
  500.             url = classOrString.toString();
  501.          }
  502.          if(cls)
  503.          {
  504.             mx_internal::contentHolder = child = new cls();
  505.             addChild(child);
  506.             contentLoaded();
  507.          }
  508.          else if(classOrString is DisplayObject)
  509.          {
  510.             mx_internal::contentHolder = child = DisplayObject(classOrString);
  511.             addChild(child);
  512.             contentLoaded();
  513.          }
  514.          else if(byteArray)
  515.          {
  516.             loader = new FlexLoader();
  517.             child = loader;
  518.             addChild(child);
  519.             loader.contentLoaderInfo.addEventListener(Event.COMPLETE,mx_internal::contentLoaderInfo_completeEventHandler);
  520.             loader.contentLoaderInfo.addEventListener(Event.INIT,contentLoaderInfo_initEventHandler);
  521.             loader.contentLoaderInfo.addEventListener(Event.UNLOAD,contentLoaderInfo_unloadEventHandler);
  522.             loader.loadBytes(byteArray,loaderContext);
  523.          }
  524.          else
  525.          {
  526.             if(!url)
  527.             {
  528.                message = resourceManager.getString("controls","notLoadable",[source]);
  529.                throw new Error(message);
  530.             }
  531.             loader = new FlexLoader();
  532.             child = loader;
  533.             addChild(loader);
  534.             loader.contentLoaderInfo.addEventListener(Event.COMPLETE,mx_internal::contentLoaderInfo_completeEventHandler);
  535.             loader.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS,contentLoaderInfo_httpStatusEventHandler);
  536.             loader.contentLoaderInfo.addEventListener(Event.INIT,contentLoaderInfo_initEventHandler);
  537.             loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,contentLoaderInfo_ioErrorEventHandler);
  538.             loader.contentLoaderInfo.addEventListener(Event.OPEN,contentLoaderInfo_openEventHandler);
  539.             loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,contentLoaderInfo_progressEventHandler);
  540.             loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,contentLoaderInfo_securityErrorEventHandler);
  541.             loader.contentLoaderInfo.addEventListener(Event.UNLOAD,contentLoaderInfo_unloadEventHandler);
  542.             if(Capabilities.isDebugger == true && url.indexOf(".jpg") == -1 && LoaderUtil.normalizeURL(Application.application.systemManager.loaderInfo).indexOf("debug=true") > -1)
  543.             {
  544.                url += url.indexOf("?") > -1 ? "&debug=true" : "?debug=true";
  545.             }
  546.             if(!(url.indexOf(":") > -1 || url.indexOf("/") == 0 || url.indexOf("\\") == 0))
  547.             {
  548.                if(SystemManagerGlobals.bootstrapLoaderInfoURL != null && SystemManagerGlobals.bootstrapLoaderInfoURL != "")
  549.                {
  550.                   rootURL = SystemManagerGlobals.bootstrapLoaderInfoURL;
  551.                }
  552.                else if(root)
  553.                {
  554.                   rootURL = LoaderUtil.normalizeURL(root.loaderInfo);
  555.                }
  556.                else if(systemManager)
  557.                {
  558.                   rootURL = LoaderUtil.normalizeURL(DisplayObject(systemManager).loaderInfo);
  559.                }
  560.                if(rootURL)
  561.                {
  562.                   lastIndex = Math.max(rootURL.lastIndexOf("\\"),rootURL.lastIndexOf("/"));
  563.                   if(lastIndex != -1)
  564.                   {
  565.                      url = rootURL.substr(0,lastIndex + 1) + url;
  566.                   }
  567.                }
  568.             }
  569.             requestedURL = new URLRequest(url);
  570.             lc = loaderContext;
  571.             if(!lc)
  572.             {
  573.                lc = new LoaderContext();
  574.                _loaderContext = lc;
  575.                if(trustContent)
  576.                {
  577.                   lc.securityDomain = SecurityDomain.currentDomain;
  578.                }
  579.                else
  580.                {
  581.                   attemptingChildAppDomain = true;
  582.                   lc.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
  583.                }
  584.             }
  585.             loader.load(requestedURL,lc);
  586.          }
  587.          invalidateDisplayList();
  588.          return child;
  589.       }
  590.       
  591.       public function get contentWidth() : Number
  592.       {
  593.          return !!mx_internal::contentHolder ? mx_internal::contentHolder.width : NaN;
  594.       }
  595.       
  596.       [Bindable("scaleContentChanged")]
  597.       public function get scaleContent() : Boolean
  598.       {
  599.          return _scaleContent;
  600.       }
  601.       
  602.       [Bindable("progress")]
  603.       public function get bytesLoaded() : Number
  604.       {
  605.          return _bytesLoaded;
  606.       }
  607.       
  608.       override protected function commitProperties() : void
  609.       {
  610.          super.commitProperties();
  611.          if(contentChanged)
  612.          {
  613.             contentChanged = false;
  614.             if(_autoLoad)
  615.             {
  616.                load(_source);
  617.             }
  618.          }
  619.       }
  620.       
  621.       private function contentLoaderInfo_securityErrorEventHandler(param1:SecurityErrorEvent) : void
  622.       {
  623.          var _loc2_:LoaderContext = null;
  624.          if(attemptingChildAppDomain)
  625.          {
  626.             attemptingChildAppDomain = false;
  627.             _loc2_ = new LoaderContext();
  628.             _loaderContext = _loc2_;
  629.             callLater(load);
  630.             return;
  631.          }
  632.          dispatchEvent(param1);
  633.       }
  634.       
  635.       public function load(param1:Object = null) : void
  636.       {
  637.          var imageData:Bitmap = null;
  638.          var url:Object = param1;
  639.          if(url)
  640.          {
  641.             _source = url;
  642.          }
  643.          if(mx_internal::contentHolder)
  644.          {
  645.             if(isContentLoaded)
  646.             {
  647.                if(mx_internal::contentHolder is Loader)
  648.                {
  649.                   try
  650.                   {
  651.                      if(Loader(mx_internal::contentHolder).content is Bitmap)
  652.                      {
  653.                         imageData = Bitmap(Loader(mx_internal::contentHolder).content);
  654.                         if(imageData.bitmapData)
  655.                         {
  656.                            imageData.bitmapData = null;
  657.                         }
  658.                      }
  659.                   }
  660.                   catch(error:Error)
  661.                   {
  662.                   }
  663.                   Loader(mx_internal::contentHolder).unload();
  664.                   if(!explicitLoaderContext)
  665.                   {
  666.                      _loaderContext = null;
  667.                   }
  668.                }
  669.                else if(mx_internal::contentHolder is Bitmap)
  670.                {
  671.                   imageData = Bitmap(mx_internal::contentHolder);
  672.                   if(imageData.bitmapData)
  673.                   {
  674.                      imageData.bitmapData = null;
  675.                   }
  676.                }
  677.             }
  678.             else if(mx_internal::contentHolder is Loader)
  679.             {
  680.                try
  681.                {
  682.                   Loader(mx_internal::contentHolder).close();
  683.                }
  684.                catch(error:Error)
  685.                {
  686.                }
  687.             }
  688.             try
  689.             {
  690.                if(mx_internal::contentHolder.parent == this)
  691.                {
  692.                   removeChild(mx_internal::contentHolder);
  693.                }
  694.             }
  695.             catch(error:Error)
  696.             {
  697.                try
  698.                {
  699.                   removeChild(mx_internal::contentHolder);
  700.                }
  701.                catch(error1:Error)
  702.                {
  703.                }
  704.             }
  705.             mx_internal::contentHolder = null;
  706.          }
  707.          isContentLoaded = false;
  708.          brokenImage = false;
  709.          if(!_source || _source == "")
  710.          {
  711.             return;
  712.          }
  713.          mx_internal::contentHolder = loadContent(_source);
  714.       }
  715.       
  716.       public function set autoLoad(param1:Boolean) : void
  717.       {
  718.          if(_autoLoad != param1)
  719.          {
  720.             _autoLoad = param1;
  721.             contentChanged = true;
  722.             invalidateProperties();
  723.             invalidateSize();
  724.             invalidateDisplayList();
  725.             dispatchEvent(new Event("autoLoadChanged"));
  726.          }
  727.       }
  728.       
  729.       private function contentLoaderInfo_initEventHandler(param1:Event) : void
  730.       {
  731.          dispatchEvent(param1);
  732.       }
  733.       
  734.       override protected function measure() : void
  735.       {
  736.          var _loc1_:Number = NaN;
  737.          var _loc2_:Number = NaN;
  738.          super.measure();
  739.          if(isContentLoaded)
  740.          {
  741.             _loc1_ = mx_internal::contentHolder.scaleX;
  742.             _loc2_ = mx_internal::contentHolder.scaleY;
  743.             mx_internal::contentHolder.scaleX = 1;
  744.             mx_internal::contentHolder.scaleY = 1;
  745.             measuredWidth = contentHolderWidth;
  746.             measuredHeight = contentHolderHeight;
  747.             mx_internal::contentHolder.scaleX = _loc1_;
  748.             mx_internal::contentHolder.scaleY = _loc2_;
  749.          }
  750.          else if(!_source || _source == "")
  751.          {
  752.             measuredWidth = 0;
  753.             measuredHeight = 0;
  754.          }
  755.       }
  756.       
  757.       private function doScaleLoader() : void
  758.       {
  759.          if(!isContentLoaded)
  760.          {
  761.             return;
  762.          }
  763.          unScaleContent();
  764.          var _loc1_:Number = unscaledWidth;
  765.          var _loc2_:Number = unscaledHeight;
  766.          if(contentHolderWidth > _loc1_ || contentHolderHeight > _loc2_)
  767.          {
  768.             mx_internal::contentHolder.scrollRect = new Rectangle(0,0,_loc1_,_loc2_);
  769.          }
  770.          else
  771.          {
  772.             mx_internal::contentHolder.scrollRect = null;
  773.          }
  774.          mx_internal::contentHolder.x = (_loc1_ - contentHolderWidth) * getHorizontalAlignValue();
  775.          mx_internal::contentHolder.y = (_loc2_ - contentHolderHeight) * getVerticalAlignValue();
  776.       }
  777.       
  778.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  779.       {
  780.          var _loc3_:Class = null;
  781.          super.updateDisplayList(param1,param2);
  782.          if(contentChanged)
  783.          {
  784.             contentChanged = false;
  785.             if(_autoLoad)
  786.             {
  787.                load(_source);
  788.             }
  789.          }
  790.          if(isContentLoaded)
  791.          {
  792.             if(_scaleContent && !brokenImage)
  793.             {
  794.                doScaleContent();
  795.             }
  796.             else
  797.             {
  798.                doScaleLoader();
  799.             }
  800.             scaleContentChanged = false;
  801.          }
  802.          if(brokenImage && !brokenImageBorder)
  803.          {
  804.             _loc3_ = getStyle("brokenImageBorderSkin");
  805.             if(_loc3_)
  806.             {
  807.                brokenImageBorder = IFlexDisplayObject(new _loc3_());
  808.                if(brokenImageBorder is ISimpleStyleClient)
  809.                {
  810.                   ISimpleStyleClient(brokenImageBorder).styleName = this;
  811.                }
  812.                addChild(DisplayObject(brokenImageBorder));
  813.             }
  814.          }
  815.          else if(!brokenImage && Boolean(brokenImageBorder))
  816.          {
  817.             removeChild(DisplayObject(brokenImageBorder));
  818.             brokenImageBorder = null;
  819.          }
  820.          if(brokenImageBorder)
  821.          {
  822.             brokenImageBorder.setActualSize(param1,param2);
  823.          }
  824.       }
  825.       
  826.       private function getVerticalAlignValue() : Number
  827.       {
  828.          var _loc1_:String = getStyle("verticalAlign");
  829.          if(_loc1_ == "top")
  830.          {
  831.             return 0;
  832.          }
  833.          if(_loc1_ == "bottom")
  834.          {
  835.             return 1;
  836.          }
  837.          return 0.5;
  838.       }
  839.       
  840.       public function get content() : DisplayObject
  841.       {
  842.          if(mx_internal::contentHolder is Loader)
  843.          {
  844.             return Loader(mx_internal::contentHolder).content;
  845.          }
  846.          return mx_internal::contentHolder;
  847.       }
  848.       
  849.       private function doScaleContent() : void
  850.       {
  851.          var interiorWidth:Number = NaN;
  852.          var interiorHeight:Number = NaN;
  853.          var contentWidth:Number = NaN;
  854.          var contentHeight:Number = NaN;
  855.          var x:Number = NaN;
  856.          var y:Number = NaN;
  857.          var newXScale:Number = NaN;
  858.          var newYScale:Number = NaN;
  859.          var scale:Number = NaN;
  860.          var w:Number = NaN;
  861.          var h:Number = NaN;
  862.          var holder:Loader = null;
  863.          var lInfo:LoaderInfo = null;
  864.          if(!isContentLoaded)
  865.          {
  866.             return;
  867.          }
  868.          if(!resizableContent || maintainAspectRatio && !flexContent)
  869.          {
  870.             unScaleContent();
  871.             interiorWidth = unscaledWidth;
  872.             interiorHeight = unscaledHeight;
  873.             contentWidth = contentHolderWidth;
  874.             contentHeight = contentHolderHeight;
  875.             x = 0;
  876.             y = 0;
  877.             newXScale = contentWidth == 0 ? 1 : interiorWidth / contentWidth;
  878.             newYScale = contentHeight == 0 ? 1 : interiorHeight / contentHeight;
  879.             if(_maintainAspectRatio)
  880.             {
  881.                if(newXScale > newYScale)
  882.                {
  883.                   x = Math.floor((interiorWidth - contentWidth * newYScale) * getHorizontalAlignValue());
  884.                   scale = newYScale;
  885.                }
  886.                else
  887.                {
  888.                   y = Math.floor((interiorHeight - contentHeight * newXScale) * getVerticalAlignValue());
  889.                   scale = newXScale;
  890.                }
  891.                mx_internal::contentHolder.scaleX = scale;
  892.                mx_internal::contentHolder.scaleY = scale;
  893.             }
  894.             else
  895.             {
  896.                mx_internal::contentHolder.scaleX = newXScale;
  897.                mx_internal::contentHolder.scaleY = newYScale;
  898.             }
  899.             mx_internal::contentHolder.x = x;
  900.             mx_internal::contentHolder.y = y;
  901.          }
  902.          else
  903.          {
  904.             mx_internal::contentHolder.x = 0;
  905.             mx_internal::contentHolder.y = 0;
  906.             w = unscaledWidth;
  907.             h = unscaledHeight;
  908.             if(mx_internal::contentHolder is Loader)
  909.             {
  910.                holder = Loader(mx_internal::contentHolder);
  911.                try
  912.                {
  913.                   if(holder.content.width > 0)
  914.                   {
  915.                      if(holder.content is IFlexDisplayObject)
  916.                      {
  917.                         IFlexDisplayObject(holder.content).setActualSize(w,h);
  918.                      }
  919.                      else
  920.                      {
  921.                         lInfo = holder.contentLoaderInfo;
  922.                         if(lInfo)
  923.                         {
  924.                            mx_internal::contentHolder.scaleX = w / lInfo.width;
  925.                            mx_internal::contentHolder.scaleY = h / lInfo.height;
  926.                         }
  927.                         else
  928.                         {
  929.                            mx_internal::contentHolder.width = w;
  930.                            mx_internal::contentHolder.height = h;
  931.                         }
  932.                      }
  933.                   }
  934.                   else if(!(holder.content is IFlexDisplayObject))
  935.                   {
  936.                      mx_internal::contentHolder.width = w;
  937.                      mx_internal::contentHolder.height = h;
  938.                   }
  939.                }
  940.                catch(error:Error)
  941.                {
  942.                   mx_internal::contentHolder.width = w;
  943.                   mx_internal::contentHolder.height = h;
  944.                }
  945.             }
  946.             else
  947.             {
  948.                mx_internal::contentHolder.width = w;
  949.                mx_internal::contentHolder.height = h;
  950.             }
  951.          }
  952.       }
  953.       
  954.       private function contentLoaderInfo_ioErrorEventHandler(param1:IOErrorEvent) : void
  955.       {
  956.          source = getStyle("brokenImageSkin");
  957.          load();
  958.          contentChanged = false;
  959.          brokenImage = true;
  960.          if(hasEventListener(param1.type))
  961.          {
  962.             dispatchEvent(param1);
  963.          }
  964.       }
  965.    }
  966. }
  967.  
  968.